package com.qf.business.system.aspect;

import com.qf.business.system.power.Auth;
import com.qf.commons.web.utils.HttpUtils;
import com.qf.data.base.r.Codes;
import com.qf.data.base.r.Rs;
import com.qf.data.system.entity.Employee;
import com.qf.data.system.entity.Power;
import com.qf.data.system.entity.Role;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.lang.reflect.Method;
import java.util.List;

/**
 * 认证授权的切面
 * description:
 * author: Ken
 * 公众号：Java架构栈
 */
@Aspect
@Component
@Order(Integer.MIN_VALUE)
public class AuthAspect {

    /**
     * 对所有的Controller的方法 进行认证授权拦截
     * @return
     */
    @Around("@within(org.springframework.web.bind.annotation.RestController)")
    public Object authHandler(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {

        //1、获取目标方法的注解
        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
        Method method = signature.getMethod();
        Auth auth = method.getAnnotation(Auth.class);

        //2、获得Session - 用户的登录凭证
        HttpServletRequest request = HttpUtils.getRequest();
        HttpSession session = request.getSession();
        //登录的员工信息
        Employee employee = (Employee) session.getAttribute("login_emp");

        //1、访问的接口有注解 而且 mustLogin = false -> 放行
        //2、已经登录了 并且 访问的接口有注解 而且 mustLogin = true -> 放行
        //3、已经登录了 但是 访问的接口没有注解 进行权限的判定
                // 1）权限通过 -> 放行
                // 2）权限未通过 -> 返回权限不足的错误信息
        //4、默认返回需要登录的错误信息

        if (auth != null && !auth.mustLogin()) {
            //无需登录就可以访问的资源
            return proceedingJoinPoint.proceed();
        }

        if (auth != null && auth.mustLogin() && employee != null) {
            //只要登录就可以访问的资源
            return proceedingJoinPoint.proceed();
        }

        if (employee != null) {
            //判断超级管理员
            if (employee.getId() == 1)
                return proceedingJoinPoint.proceed();

            //直接判断权限
            //1、获得需要访问的资源
            String requestURI = request.getRequestURI();
            System.out.println("需要访问的资源：" + requestURI);
            //2、获得当前用户拥有的权限信息
            List<Role> roles = employee.getRoles();
            List<Power> powers = employee.getPowers();

            //URI比较的对象 - 通配符的匹配
            AntPathMatcher antPathMatcher = new AntPathMatcher();

            //3、循环所有的权限 - 和请求的资源做对比
            for (Power power : powers) {
                if (!StringUtils.isEmpty(power.getPowerResource())
                        && antPathMatcher.match(power.getPowerResource(), requestURI)) {
                    //资源匹配成功
                    return proceedingJoinPoint.proceed();
                }
            }

            //权限不足
            return Rs.createFail(Codes.NO_POWER);
        }

        //默认返回
        return Rs.createFail(Codes.NOT_LOGIN);


//        if (employee != null) {
//            //判断是否为超级管理员
//            if (employee.getId() == 1) {
//                //当前为超级管理员，直接放行
//                return proceedingJoinPoint.proceed();
//            }
//
//            //已经登录
//            if(employee.getStatus() == 0) {
//                //还未修改密码，强制返回错误状态
//                return Rs.createFail(Codes.USER_PASSWORD_WARN);
//            }
//        }

        //放行
//        return proceedingJoinPoint.proceed();
    }
}
